// 版权所有2009 Go作者。版权所有。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

// 包bufio实现缓冲I/O。它封装了一个io。读卡器或io。编写器
// 对象，创建另一个对象（读写器），该对象也实现了
// 接口，但为文本I/O提供缓冲和一些帮助。
package bufio

import (
	"bytes"
	"errors"
	"io"
	"strings"
	"unicode/utf8"
)

const (
	defaultBufSize = 4096
)

var (
	ErrInvalidUnreadByte = errors.New("bufio: invalid use of UnreadByte")
	ErrInvalidUnreadRune = errors.New("bufio: invalid use of UnreadRune")
	ErrBufferFull        = errors.New("bufio: buffer full")
	ErrNegativeCount     = errors.New("bufio: negative count")
)

// 缓冲输入。

// 读卡器为io实现缓冲。读卡器对象。
type Reader struct {
	buf          []byte
	rd           io.Reader // 客户端提供的读卡器
	r, w         int       // buf读写位置
	err          error
	lastByte     int // 未读字节的最后一个字节读取-1表示无效
	lastRuneSize int // 未读符文最后读取的符文大小-1表示无效的
}

const minReadBufferSize = 16
const maxConsecutiveEmptyReads = 100

// NewReaderSize返回一个新的读取器，该读取器的缓冲区至少具有指定的
// 大小。如果论点成立。Reader已经是一个足够大的读卡器
// size，它返回底层读卡器。
func NewReaderSize(rd io.Reader, size int) *Reader {
	// 它已经有读者了吗？
	b, ok := rd.(*Reader)
	if ok && len(b.buf) >= size {
		return b
	}
	if size < minReadBufferSize {
		size = minReadBufferSize
	}
	r := new(Reader)
	r.reset(make([]byte, size), rd)
	return r
}

// NewReader返回一个缓冲区大小为默认值的新读取器。
func NewReader(rd io.Reader) *Reader {
	return NewReaderSize(rd, defaultBufSize)
}

// Size返回基础缓冲区的大小（字节）。
func (b *Reader) Size() int { return len(b.buf) }

// 重置丢弃所有缓冲数据，重置所有状态，并将
// 缓冲读取器切换为从r读取。
// 在读取器的零值上调用重置将内部缓冲区
// 初始化为默认大小。
func (b *Reader) Reset(r io.Reader) {
	if b.buf == nil {
		b.buf = make([]byte, defaultBufSize)
	}
	b.reset(b.buf, r)
}

func (b *Reader) reset(buf []byte, r io.Reader) {
	*b = Reader{
		buf:          buf,
		rd:           r,
		lastByte:     -1,
		lastRuneSize: -1,
	}
}

var errNegativeRead = errors.New("bufio: reader returned negative count from Read")

// fill将一个新块读入缓冲区。
func (b *Reader) fill() {
	// 将现有数据滑到开头。
	if b.r > 0 {
		copy(b.buf, b.buf[b.r:b.w])
		b.w -= b.r
		b.r = 0
	}

	if b.w >= len(b.buf) {
		panic("bufio: tried to fill full buffer")
	}

	// 读取新数据：尝试有限的次数。
	for i := maxConsecutiveEmptyReads; i > 0; i-- {
		n, err := b.rd.Read(b.buf[b.w:])
		if n < 0 {
			panic(errNegativeRead)
		}
		b.w += n
		if err != nil {
			b.err = err
			return
		}
		if n > 0 {
			return
		}
	}
	b.err = io.ErrNoProgress
}

func (b *Reader) readErr() error {
	err := b.err
	b.err = nil
	return err
}

// Peek返回接下来的n个字节，而不推进读取器。字节停止
// 在下一次读取调用时有效。如果Peek返回的字节数少于n，则返回
// 并返回一个错误，解释读取的长度为何较短。如果n大于b的缓冲区大小，则错误为
// ErrBufferFull。
// 
// 调用Peek可防止未读字节或未读单元调用在下一次读取操作之前继续进行。
func (b *Reader) Peek(n int) ([]byte, error) {
	if n < 0 {
		return nil, ErrNegativeCount
	}

	b.lastByte = -1
	b.lastRuneSize = -1

	for b.w-b.r < n && b.w-b.r < len(b.buf) && b.err == nil {
		b.fill() // b.w-b.r<len（b.buf）=>缓冲区未满
	}

	if n > len(b.buf) {
		return b.buf[b.r:b.w], ErrBufferFull
	}

	// 0<=n<=len（b.buf）
	var err error
	if avail := b.w - b.r; avail < n {
		// 缓冲区中的数据不足
		n = avail
		err = b.readErr()
		if err == nil {
			err = ErrBufferFull
		}
	}
	return b.buf[b.r : b.r+n], err
}

// 丢弃跳过接下来的n个字节，返回丢弃的字节数。
// 
// 如果Discard跳过的字节数少于n，它也会返回一个错误。
// 如果0<=n<=b.Buffered（），则在不从基础io读取
// 的情况下，保证放弃成功。读者
func (b *Reader) Discard(n int) (discarded int, err error) {
	if n < 0 {
		return 0, ErrNegativeCount
	}
	if n == 0 {
		return
	}

	b.lastByte = -1
	b.lastRuneSize = -1

	remain := n
	for {
		skip := b.Buffered()
		if skip == 0 {
			b.fill()
			skip = b.Buffered()
		}
		if skip > remain {
			skip = remain
		}
		b.r += skip
		remain -= skip
		if remain == 0 {
			return n, nil
		}
		if b.err != nil {
			return n - remain, b.readErr()
		}
	}
}

// Read reads data to p.
// 返回读入p的字节数。
// 这些字节来自底层读取器上最多一次读取，因此n可能小于len（p）。
// 要准确读取len（p）字节，请使用io。ReadFull（b，p）。
// 在EOF时，计数将为零，错误将为io。EOF。
func (b *Reader) Read(p []byte) (n int, err error) {
	n = len(p)
	if n == 0 {
		if b.Buffered() > 0 {
			return 0, nil
		}
		return 0, b.readErr()
	}
	if b.r == b.w {
		if b.err != nil {
			return 0, b.readErr()
		}
		if len(p) >= len(b.buf) {
			// 大读取，空缓冲区。
			// 直接读入p以避免复制。
			n, b.err = b.rd.Read(p)
			if n < 0 {
				panic(errNegativeRead)
			}
			if n > 0 {
				b.lastByte = int(p[n-1])
				b.lastRuneSize = -1
			}
			return n, b.readErr()
		}
		// 一读。
		// 不要使用b.fill，这会导致循环。
		b.r = 0
		b.w = 0
		n, b.err = b.rd.Read(b.buf)
		if n < 0 {
			panic(errNegativeRead)
		}
		if n == 0 {
			return 0, b.readErr()
		}
		b.w += n
	}

	// 尽可能多地复制
	// 注意：如果切片在这里出现恐慌，可能是因为
	// 基础读取器返回了一个错误的计数。见第49795期。
	n = copy(p, b.buf[b.r:b.w])
	b.r += n
	b.lastByte = int(b.buf[b.r-1])
	b.lastRuneSize = -1
	return n, nil
}

// ReadByte读取并返回一个字节。
// 如果没有可用字节，则返回错误。
func (b *Reader) ReadByte() (byte, error) {
	b.lastRuneSize = -1
	for b.r == b.w {
		if b.err != nil {
			return 0, b.readErr()
		}
		b.fill() // 缓冲区为空
	}
	c := b.buf[b.r]
	b.r++
	b.lastByte = int(c)
	return c, nil
}

// 未读字节未读最后一个字节。只能读取最近读取的字节。如果在
// 读取器上调用的最新方法不是读取操作，则返回错误。值得注意的是，Peek、Discard和WriteTo不是
// 被认为是读取操作。
func (b *Reader) UnreadByte() error {
	if b.lastByte < 0 || b.r == 0 && b.w > 0 {
		return ErrInvalidUnreadByte
	}
	// b.r>0 | | b.w==0 
	if b.r > 0 {
		b.r--
	} else {
		// b.r==0&&b.w==0 
		b.w = 1
	}
	b.buf[b.r] = byte(b.lastByte)
	b.lastByte = -1
	b.lastRuneSize = -1
	return nil
}

// ReadRune读取单个UTF-8编码的Unicode字符，并返回
// rune及其字节大小。如果编码的符文无效，它将消耗一个字节
// 并返回unicode。替换字符（U+FFFD），大小为1。
func (b *Reader) ReadRune() (r rune, size int, err error) {
	for b.r+utf8.UTFMax > b.w && !utf8.FullRune(b.buf[b.r:b.w]) && b.err == nil && b.w-b.r < len(b.buf) {
		b.fill() // b.w-b.r<len（buf）=>缓冲区未满。如果最近在
	}
	b.lastRuneSize = -1
	if b.r == b.w {
		return 0, 0, b.readErr()
	}
	r, size = rune(b.buf[b.r]), 1
	if r >= utf8.RuneSelf {
		r, size = utf8.DecodeRune(b.buf[b.r:b.w])
	}
	b.r += size
	b.lastByte = int(b.buf[b.r-1])
	b.lastRuneSize = size
	return r, size, nil
}

// /上调用的方法不是ReadRune，则UnreadRune将返回一个错误。（在此
// 中，它比未读字节更严格，它将从任何读操作中未读最后一个字节
// 。）
func (b *Reader) UnreadRune() error {
	if b.lastRuneSize < 0 || b.r < b.lastRuneSize {
		return ErrInvalidUnreadRune
	}
	b.r -= b.lastRuneSize
	b.lastByte = -1
	b.lastRuneSize = -1
	return nil
}

// Buffered返回可以从当前缓冲区读取的字节数。
func (b *Reader) Buffered() int { return b.w - b.r }

// 读取切片直到输入中第一次出现delim，
// 返回指向缓冲区中字节的切片。
// 字节在下一次读取时不再有效。
// 如果ReadSlice在查找分隔符之前遇到错误，
// 它将返回缓冲区中的所有数据和错误本身（通常是io.EOF）。
// 如果缓冲区在没有delim的情况下填充，ReadSlice将失败，并出现错误ErrBufferFull。
// 由于从ReadSlice返回的数据将被下一次I/O操作覆盖，大多数客户端应该使用
// ReadBytes或ReadString。wen jian defg
func (b *Reader) ReadSlice(delim byte) (line []byte, err error) {
	s := 0 // 搜索开始索引
	for {
		// 搜索缓冲区。
		if i := bytes.IndexByte(b.buf[b.r+s:b.w], delim); i >= 0 {
			i += s
			line = b.buf[b.r : b.r+i+1]
			b.r += i + 1
			break
		}

		// 挂起的错误？
		if b.err != nil {
			line = b.buf[b.r:b.w]
			b.r = b.w
			err = b.readErr()
			break
		}

		// 缓冲区已满？
		if b.Buffered() >= len(b.buf) {
			b.r = b.w
			line = b.buf
			err = ErrBufferFull
			break
		}

		s = b.w - b.r // 请勿重新扫描我们在

		b.fill() // 缓冲区未满
	}

	// 处理最后一个字节（如果有）。
	if i := len(line) - 1; i >= 0 {
		b.lastByte = int(line[i])
		b.lastRuneSize = -1
	}

	return
}

// ReadLine是一种低级的行读取原语。大多数呼叫者应该使用
// ReadBytes（'\n'）或ReadString（'\n'），或者使用扫描仪。
// 
// ReadLine尝试返回一行，不包括行尾字节。
// 如果该行对于缓冲区来说太长，则设置isPrefix并返回该行的开头。该线路的其余部分将从以后的通话中返回
// 。当返回行的最后一个片段
// 时，isPrefix将为false。返回的缓冲区仅在下次调用
// ReadLine之前有效。
// 
// 从ReadLine返回的文本不包括行尾（“\r\n”或“\n”）。
// 如果输入结束时没有最后一行结束，则不会给出任何指示或错误。
// 在ReadLine之后调用UnreadByte将始终未读取读取的最后一个字节
// （可能是属于行尾的字符），即使该字节不是ReadLine返回的行的
// 部分。
func (b *Reader) ReadLine() (line []byte, isPrefix bool, err error) {
	line, err = b.ReadSlice('\n')
	if err == ErrBufferFull {
		// 处理“\r\n”跨越缓冲区的情况。
		if len(line) > 0 && line[len(line)-1] == '\r' {
			// 将“\r”放回buf并从行中删除。
			// 让对ReadLine的下一个调用检查“\r\n”。
			if b.r == 0 {
				// 应该是无法访问的
				panic("bufio: tried to rewind past start of buffer")
			}
			b.r--
			line = line[:len(line)-1]
		}
		return line, true, nil
	}

	if len(line) == 0 {
		if err != nil {
			line = nil
		}
		return
	}
	err = nil

	if line[len(line)-1] == '\n' {
		drop := 1
		if len(line) > 1 && line[len(line)-2] == '\r' {
			drop = 2
		}
		line = line[:len(line)-drop]
	}
	return
}

// 在输入中第一次出现delim之前，collectFragments读取。返回（完整缓冲区的切片，delim之前的剩余字节，前两个组合元素中字节的总数，错误）。
// 完整结果等于
// /`字节。Join（append（fullBuffers，finalFragment），nil）`，它的
// 长度为'totalen'。结果的结构允许调用方
// 最小化分配和拷贝。
func (b *Reader) collectFragments(delim byte) (fullBuffers [][]byte, finalFragment []byte, totalLen int, err error) {
	var frag []byte
	// 使用ReadSlice查找delim，积累完整的缓冲区。
	for {
		var e error
		frag, e = b.ReadSlice(delim)
		if e == nil { // 获取了最终片段
			break
		}
		if e != ErrBufferFull { // 意外错误
			err = e
			break
		}

		// 复制缓冲区。
		buf := make([]byte, len(frag))
		copy(buf, frag)
		fullBuffers = append(fullBuffers, buf)
		totalLen += len(buf)
	}

	totalLen += len(frag)
	return fullBuffers, frag, totalLen, err
}

// 读取字节数，直到输入中第一次出现delim，
// 返回一个包含数据的切片，该切片最多包含分隔符。
// 如果ReadBytes在查找分隔符之前遇到错误，
// 它将返回在错误之前读取的数据以及错误本身（通常是io.EOF）。
// ReadBytes返回错误！=nil当且仅当返回的数据不以
// delim结尾时。
// 对于简单的使用，扫描仪可能更方便。
func (b *Reader) ReadBytes(delim byte) ([]byte, error) {
	full, frag, n, err := b.collectFragments(delim)
	// 分配新的缓冲区来保存完整的片段和片段。
	buf := make([]byte, n)
	n = 0
	// 复制完整的片段和片段。
	for i := range full {
		n += copy(buf[n:], full[i])
	}
	copy(buf[n:], frag)
	return buf, err
}

// 读取字符串，直到输入中第一次出现delim，
// 返回一个包含数据的字符串，该字符串包含分隔符。
// 如果ReadString在查找分隔符之前遇到错误，
// 它将返回在错误之前读取的数据以及错误本身（通常是io.EOF）。
// ReadString返回错误！=nil当且仅当返回的数据不以
// delim结尾时。
// 对于简单的使用，扫描仪可能更方便。
func (b *Reader) ReadString(delim byte) (string, error) {
	full, frag, n, err := b.collectFragments(delim)
	// 分配新的缓冲区来保存完整的片段和片段。
	var buf strings.Builder
	buf.Grow(n)
	// 复制完整的片段和片段。
	for _, fb := range full {
		buf.Write(fb)
	}
	buf.Write(frag)
	return buf.String(), err
}

// 写入以实现io。WriterTo。
// 这可能会多次调用底层读取器的Read方法。
// 如果基础读取器支持WriteTo方法，则
// 这将调用基础WriteTo而不进行缓冲。
func (b *Reader) WriteTo(w io.Writer) (n int64, err error) {
	b.lastByte = -1
	b.lastRuneSize = -1

	n, err = b.writeBuf(w)
	if err != nil {
		return
	}

	if r, ok := b.rd.(io.WriterTo); ok {
		m, err := r.WriteTo(w)
		n += m
		return n, err
	}

	if w, ok := w.(io.ReaderFrom); ok {
		m, err := w.ReadFrom(b.rd)
		n += m
		return n, err
	}

	if b.w-b.r < len(b.buf) {
		b.fill() // 缓冲区未满
	}

	for b.r < b.w {
		// b.r<b.w=>缓冲区不为空
		m, err := b.writeBuf(w)
		n += m
		if err != nil {
			return n, err
		}
		b.fill() // 缓冲区为空
	}

	if b.err == io.EOF {
		b.err = nil
	}

	return n, b.readErr()
}

var errNegativeWrite = errors.New("bufio: writer returned negative count from Write")

// writeBuf将读取器的缓冲区写入写入器。
func (b *Reader) writeBuf(w io.Writer) (int64, error) {
	n, err := w.Write(b.buf[b.r:b.w])
	if n < 0 {
		panic(errNegativeWrite)
	}
	b.r += n
	return int64(n), err
}

// 缓冲输出

// Writer为io实现缓冲。Writer对象。
// 如果写入写入程序时发生错误，将不再接受更多数据
// 所有后续写入和刷新都将返回错误。
// 写入所有数据后，客户端应调用
// Flush方法，以确保所有数据已转发至
// 底层io。作家
type Writer struct {
	err error
	buf []byte
	n   int
	wr  io.Writer
}

// NewWriterSize返回一个新的写入程序，其缓冲区至少具有指定的
// 大小。如果论点成立。Writer已经是一个具有足够大
// 大小的Writer，它返回基础Writer。
func NewWriterSize(w io.Writer, size int) *Writer {
	// 它已经是作家了吗？
	b, ok := w.(*Writer)
	if ok && len(b.buf) >= size {
		return b
	}
	if size <= 0 {
		size = defaultBufSize
	}
	return &Writer{
		buf: make([]byte, size),
		wr:  w,
	}
}

// NewWriter返回一个缓冲区大小为默认值的新Writer。
// 如果参数为io。Writer已经是一个缓冲区大小足够大的Writer，
// 它返回底层Writer。
func NewWriter(w io.Writer) *Writer {
	return NewWriterSize(w, defaultBufSize)
}

// Size返回基础缓冲区的大小（字节）。
func (b *Writer) Size() int { return len(b.buf) }

// 重置将丢弃所有未刷新的缓冲数据，清除所有错误，并将b重置为将其输出写入w。
// 调用Writer的零值重置将内部缓冲区
// 初始化为默认大小。
func (b *Writer) Reset(w io.Writer) {
	if b.buf == nil {
		b.buf = make([]byte, defaultBufSize)
	}
	b.err = nil
	b.n = 0
	b.wr = w
}

// Flush将所有缓冲数据写入基础io。作家
func (b *Writer) Flush() error {
	if b.err != nil {
		return b.err
	}
	if b.n == 0 {
		return nil
	}
	n, err := b.wr.Write(b.buf[0:b.n])
	if n < b.n && err == nil {
		err = io.ErrShortWrite
	}
	if err != nil {
		if n > 0 && n < b.n {
			copy(b.buf[0:b.n-n], b.buf[n:b.n])
		}
		b.n -= n
		b.err = err
		return err
	}
	b.n = 0
	return nil
}

// Available返回缓冲区中未使用的字节数。
func (b *Writer) Available() int { return len(b.buf) - b.n }

// AvailableBuffer返回一个容量为b.Available（）的空缓冲区。
// 此缓冲区将被追加，并将
// 传递给紧接着的写调用。
// 缓冲区仅在b上的下一次写入操作之前有效。
func (b *Writer) AvailableBuffer() []byte {
	return b.buf[b.n:][:0]
}

// Buffered返回已写入当前缓冲区的字节数。
func (b *Writer) Buffered() int { return b.n }

// Write将p的内容写入缓冲区。
// 返回写入的字节数。
// 如果nn<len（p），它还会返回一个错误，解释
// 为什么写短。
func (b *Writer) Write(p []byte) (nn int, err error) {
	for len(p) > b.Available() && b.err == nil {
		var n int
		if b.Buffered() == 0 {
			// 大写入，空缓冲区。
			// 直接从p写入以避免复制。
			n, b.err = b.wr.Write(p)
		} else {
			n = copy(b.buf[b.n:], p)
			b.n += n
			b.Flush()
		}
		nn += n
		p = p[n:]
	}
	if b.err != nil {
		return nn, b.err
	}
	n := copy(b.buf[b.n:], p)
	b.n += n
	nn += n
	return nn, nil
}

// WriteByte写入一个字节。
func (b *Writer) WriteByte(c byte) error {
	if b.err != nil {
		return b.err
	}
	if b.Available() <= 0 && b.Flush() != nil {
		return b.err
	}
	b.buf[b.n] = c
	b.n++
	return nil
}

// WriteRune写入单个Unicode代码点，返回
// 写入的字节数和任何错误。
func (b *Writer) WriteRune(r rune) (size int, err error) {
	// 比较as uint32以正确处理负面符文。
	if uint32(r) < utf8.RuneSelf {
		err = b.WriteByte(byte(r))
		if err != nil {
			return 0, err
		}
		return 1, nil
	}
	if b.err != nil {
		return 0, b.err
	}
	n := b.Available()
	if n < utf8.UTFMax {
		if b.Flush(); b.err != nil {
			return 0, b.err
		}
		n = b.Available()
		if n < utf8.UTFMax {
			// 只有在缓冲区非常小的情况下才会发生。
			return b.WriteString(string(r))
		}
	}
	size = utf8.EncodeRune(b.buf[b.n:], r)
	b.n += size
	return size, nil
}

// WriteString写入字符串。
// 返回写入的字节数。
// 如果计数小于len（s），它还会返回一个错误，解释
// 为什么写入短。
func (b *Writer) WriteString(s string) (int, error) {
	nn := 0
	for len(s) > b.Available() && b.err == nil {
		n := copy(b.buf[b.n:], s)
		b.n += n
		nn += n
		s = s[n:]
		b.Flush()
	}
	if b.err != nil {
		return nn, b.err
	}
	n := copy(b.buf[b.n:], s)
	b.n += n
	nn += n
	return nn, nil
}

// 从io读取。ReaderFrom。如果底层编写器
// 支持ReadFrom方法，则调用底层ReadFrom。
// 如果存在缓冲数据和基础ReadFrom，这将填充缓冲区并在调用ReadFrom之前写入。
func (b *Writer) ReadFrom(r io.Reader) (n int64, err error) {
	if b.err != nil {
		return 0, b.err
	}
	readerFrom, readerFromOK := b.wr.(io.ReaderFrom)
	var m int
	for {
		if b.Available() == 0 {
			if err1 := b.Flush(); err1 != nil {
				return n, err1
			}
		}
		if readerFromOK && b.Buffered() == 0 {
			nn, err := readerFrom.ReadFrom(r)
			b.err = err
			n += nn
			return n, err
		}
		nr := 0
		for nr < maxConsecutiveEmptyReads {
			m, err = r.Read(b.buf[b.n:])
			if m != 0 || err != nil {
				break
			}
			nr++
		}
		if nr == maxConsecutiveEmptyReads {
			return n, io.ErrNoProgress
		}
		b.n += m
		n += int64(m)
		if err != nil {
			break
		}
	}
	if err == io.EOF {
		// 如果我们准确地填充了缓冲区，则先进行刷新。
		if b.Available() == 0 {
			err = b.Flush()
		} else {
			err = nil
		}
	}
	return n, err
}

// 缓冲输入和输出

// 读写器存储指向读写器的指针。
// 它实现io。ReadWriter。
type ReadWriter struct {
	*Reader
	*Writer
}

// NewReadWriter分配一个新的ReadWriter，发送给r和w。
func NewReadWriter(r *Reader, w *Writer) *ReadWriter {
	return &ReadWriter{r, w}
}
